| 1 | #ifndef STATISTIC_H |
| 2 | #define STATISTIC_H |
| 3 | #include <iostream> |
| 4 | #include <deque> |
| 5 | #include <numeric> |
| 6 | #include <algorithm> |
| 7 | #include <sstream> |
| 8 | #include <cmath> |
| 9 | #include <vector> |
| 10 | |
| 11 | template <class T> |
| 12 | class STATISTIC |
| 13 | { |
| 14 | public: |
| 15 | STATISTIC(unsigned int size): m_size(size) |
385 | 16 | { |
385 | 17 | |
385 | 18 | } |
3 | 19 | void resize(unsigned int i){ |
3 | 20 | if (i < m_size){ |
24 | 21 | while(m_dequeue.size()> i){ |
21 | 22 | pop_front(); |
21 | 23 | } |
3 | 24 | } |
3 | 25 | m_size = i; |
3 | 26 | } |
79 | 27 | T size(){ |
79 | 28 | return static_cast<T>(m_dequeue.size()); |
79 | 29 | } |
10 | 30 | void push_front(T v){ |
10 | 31 | if (m_dequeue.size() >= m_size){ |
1 | 32 | pop_back(); |
1 | 33 | } |
10 | 34 | m_dequeue.push_front(v); |
10 | 35 | } |
307 | 36 | void push_back(T v){ |
307 | 37 | if (m_dequeue.size() >= m_size){ |
2 | 38 | pop_front(); |
2 | 39 | } |
307 | 40 | m_dequeue.push_back(v); |
307 | 41 | } |
3 | 42 | void pop_back(){ |
3 | 43 | m_dequeue.pop_back(); |
3 | 44 | // std::cout <<"pop_back"<<std::endl; |
3 | 45 | } |
23 | 46 | void pop_front(){ |
23 | 47 | m_dequeue.pop_front(); |
23 | 48 | // std::cout <<"pop_front"<<std::endl; |
23 | 49 | } |
| 50 | ///////////////////////////////////////////// statistic ///////////////////////////// |
5 | 51 | T median(){ |
5 | 52 | auto backup = m_dequeue; |
5 | 53 | std::sort(backup.begin(), backup.end()); |
5 | 54 | if (backup.size() % 2 != 0){ |
3 | 55 | return backup[backup.size() / 2]; |
3 | 56 | } |
2 | 57 | else{ |
2 | 58 | T m = backup[backup.size() / 2] + backup[(backup.size() / 2)-1]; |
2 | 59 | return m /2 ; |
2 | 60 | } |
5 | 61 | } |
23 | 62 | T sum(){ |
23 | 63 | return std::accumulate(m_dequeue.begin(), m_dequeue.end(), static_cast<T>(0)); |
23 | 64 | } |
| 65 | |
23 | 66 | T average(){ |
23 | 67 | T av = sum() /size(); |
23 | 68 | return av; |
23 | 69 | } |
| 70 | |
5 | 71 | T max(){ |
5 | 72 | T max = m_dequeue[0]; |
40 | 73 | for (auto v : m_dequeue){ |
40 | 74 | if (v > max){ |
13 | 75 | max = v; |
13 | 76 | } |
40 | 77 | } |
5 | 78 | return max; |
5 | 79 | } |
| 80 | |
5 | 81 | T min(){ |
5 | 82 | T min = m_dequeue[0]; |
40 | 83 | for (auto v : m_dequeue){ |
40 | 84 | if (v < min){ |
3 | 85 | min = v; |
3 | 86 | } |
40 | 87 | } |
5 | 88 | return min; |
5 | 89 | } |
| 90 | |
1 | 91 | T range(){ |
1 | 92 | return max() - min(); |
1 | 93 | } |
| 94 | |
6 | 95 | T standardDeviation(){ |
6 | 96 | double standardDeviation = 0.0; |
6 | 97 | T _av = average(); |
6 | 98 | |
38 | 99 | for(int i = 0; i < size(); ++i){ |
32 | 100 | standardDeviation += pow(m_dequeue.at(i) - _av, 2); |
32 | 101 | } |
6 | 102 | return sqrt(standardDeviation / size()); |
6 | 103 | } |
| 104 | |
3 | 105 | T coefficientOfVariation(){ |
3 | 106 | |
3 | 107 | return (standardDeviation()/average()) /** 100*/; |
3 | 108 | } |
| 109 | |
13 | 110 | T mode(){ |
13 | 111 | |
13 | 112 | T _mode = 0; |
13 | 113 | T _modeTemp = 0; |
13 | 114 | int counter = 1; |
13 | 115 | int modeCounter = 1; |
13 | 116 | auto backup = m_dequeue; |
13 | 117 | if(m_dequeue.size() == 1) |
3 | 118 | { |
3 | 119 | return m_dequeue.at(0); |
3 | 120 | } |
10 | 121 | std::sort(backup.begin(), backup.end()); |
10 | 122 | #ifdef BT_TEST |
10 | 123 | std::cout << " " << std::endl; |
10 | 124 | for (auto i : backup) |
89 | 125 | { |
89 | 126 | std::cout << i << " "; |
89 | 127 | } |
10 | 128 | std::cout << " " << std::endl; |
10 | 129 | #endif |
10 | 130 | _mode = _modeTemp = backup.at(0); |
10 | 131 | backup.pop_front(); |
10 | 132 | for (auto b : backup) |
79 | 133 | { |
79 | 134 | if (_modeTemp == b) |
15 | 135 | { |
15 | 136 | modeCounter++; |
15 | 137 | } |
79 | 138 | else |
64 | 139 | { |
64 | 140 | _modeTemp = b; |
64 | 141 | modeCounter = 1; |
64 | 142 | } |
79 | 143 | |
79 | 144 | if(counter < modeCounter) |
8 | 145 | { |
8 | 146 | counter = modeCounter; |
8 | 147 | _mode = _modeTemp; |
8 | 148 | } |
79 | 149 | } |
10 | 150 | #ifdef BT_TEST |
10 | 151 | std::cout << " moda: " << _mode << " wystepuje razy " << counter << std::endl; |
10 | 152 | #endif |
10 | 153 | return _mode; |
13 | 154 | } |
| 155 | |
| 156 | float trend(){ |
| 157 | int down = 0; |
| 158 | int eq = 0; |
| 159 | int up = 0; |
| 160 | int lp = 0; |
| 161 | T diff = 0; |
| 162 | T first = m_dequeue[0]; |
| 163 | |
| 164 | for (auto i = 1 ; i < m_dequeue.size(); ++i){ |
| 165 | if (first < m_dequeue[i]){ |
| 166 | up++; |
| 167 | if (m_dequeue[i] - first > diff){ |
| 168 | diff = m_dequeue[i] - first; |
| 169 | lp = i; |
| 170 | } |
| 171 | } |
| 172 | if (first == m_dequeue[i]){ eq++;} |
| 173 | if (first > m_dequeue[i]){ |
| 174 | if (diff < first - m_dequeue[i] ){ |
| 175 | diff = first - m_dequeue[i]; |
| 176 | lp = i; |
| 177 | } |
| 178 | down++; |
| 179 | } |
| 180 | first = m_dequeue[i]; |
| 181 | } |
| 182 | std::cout <<"up "<<up<<" eq "<< eq << " down "<< down <<" max diff "<< diff<<" lp "<<lp << std::endl; |
| 183 | return 2.2; |
| 184 | } |
| 185 | |
20 | 186 | bool isMoreDiff(T diff){ |
20 | 187 | if (m_dequeue.size()>2){ |
14 | 188 | T d = m_dequeue.at( m_dequeue.size()-2) |
14 | 189 | - m_dequeue.at( m_dequeue.size() - 1); |
14 | 190 | d = fabs(d); |
14 | 191 | if (d > diff && m_alarm == false){ |
6 | 192 | m_alarm = true; |
6 | 193 | return true; |
6 | 194 | } |
8 | 195 | if (d <= diff){ |
8 | 196 | m_alarm = false; |
8 | 197 | return false; |
8 | 198 | } |
8 | 199 | } |
6 | 200 | return false; |
20 | 201 | } |
7 | 202 | std::pair<double,double> getLast2(){ |
7 | 203 | if (m_dequeue.size()>2){ |
6 | 204 | return std::make_pair(static_cast<double>(m_dequeue.at( m_dequeue.size()-2)), |
6 | 205 | static_cast<double>(m_dequeue.at( m_dequeue.size()-1)) ); |
6 | 206 | } |
7 | 207 | #ifdef BT_TEST |
1 | 208 | puts("no data - return 0.0 0.0"); |
1 | 209 | #endif |
1 | 210 | return std::make_pair(0.0,0.0); |
7 | 211 | } |
| 212 | |
| 213 | ///////////////////////////////////////////////////////////////////////////////////// |
14 | 214 | void print(){ |
71 | 215 | for(auto n : m_dequeue){ |
71 | 216 | std::cout << ","<< n ; |
71 | 217 | } |
14 | 218 | std::cout << " " <<std::endl; |
14 | 219 | } |
| 220 | |
| 221 | |
4 | 222 | std::string stats(){ |
4 | 223 | |
4 | 224 | std::stringstream ss(" brak danych =("); |
4 | 225 | if(size()>0) |
3 | 226 | { |
3 | 227 | ss.str(""); |
3 | 228 | ss <<"rozmiar tablicy: "<< size() <<std::endl |
3 | 229 | << "min: "<< min() <<std::endl |
3 | 230 | << "max: "<< max()<<std::endl |
3 | 231 | << "srednia " << average() <<std::endl |
3 | 232 | << "mediana " << median() <<std::endl |
3 | 233 | << "odchylenie st "<< standardDeviation() << std::endl |
3 | 234 | << "wspolczynnik zmiennosci " << coefficientOfVariation() <<"%"<< std::endl |
3 | 235 | << "Dominanta " << mode(); |
3 | 236 | |
3 | 237 | |
3 | 238 | ss << std::endl |
3 | 239 | << "data " << std::endl; |
16 | 240 | for(auto n : m_dequeue){ |
16 | 241 | ss << "|"<< n ; |
16 | 242 | } |
3 | 243 | } |
4 | 244 | ss << std::endl; |
4 | 245 | return ss.str(); |
4 | 246 | } |
| 247 | |
| 248 | private: |
| 249 | unsigned int m_size; |
| 250 | std::deque <T> m_dequeue; |
| 251 | bool m_alarm = false; |
| 252 | }; |
| 253 | |
| 254 | #endif // STATISTIC_H |